
class Foo {

  // 静态属性
  static sBar = '父类静态属性sBar'
  // 私有属性
  #name = '父类私有属性#name'
  // 普通属性
  sex = '父类普通属性sex'

  // 获取器
  get name (){
    return this.#name
  }

  // 存储器
  set name (value){
      this.#name = value
  }


  // 静态方法bar
  static bar() {
    // 静态方法bar调用了this.baz，这里的this指的是Foo类，而不是Foo的实例，
    this.baz();
  }
  // 静态方法baz
  static baz() {
    console.log('hello000000');
  }
  // 普通方法baz
  baz() {
    console.log('父类：world#######'+this.#name);
  }
 // 普通方法bazf00
  bazf00() {
    // 谁调用就是谁
    this.baz()
  }
}


class Shuiguo2 extends Foo{}

let sg2 = new Shuiguo2()

console.log( sg2.name); // 正常调用父类的
console.log(sg2.sex);
sg2.bazf00()
sg2.bazf111()
Shuiguo.bar()
console.log(Shuiguo.sBar);



class Foo000 {

  // 静态属性
  static sBar = '父类静态属性sBar'
  // 私有属性
  #name = '父类私有属性#name'
  // 普通属性
  sex = '父类普通属性sex'

  // 构造函数
  constructor(msg){
    console.log(msg);
  }

  // 获取器
  get name (){
    return this.#name
  }

  // 存储器
  set name (value){
      this.#name = value
  }


  // 静态方法bar
  static bar() {
    // 静态方法bar调用了this.baz，这里的this指的是Foo类，而不是Foo的实例，
    this.baz();
  }
  // 静态方法baz
  static baz() {
    console.log('hello000000');
  }
  // 普通方法baz
  baz() {
    console.log('父类：world#######'+this.#name);
  }
 // 普通方法bazf00
  bazf00() {
    // 谁调用就是谁
    this.baz()
  }
}





class Shuiguo extends Foo000{

  name
  // sex = '子类的sex'
  
  constructor(name){
    // 如果继承了父类，并且给子类加上了 构造函数 constructor 
    // 子类的构造函数就把父类的构造函数覆盖，也就是父类无法完成实例化 
    // 所以需要再子类的构造函数·开始的地方·，使用super调用父类的构造函数
    super('调用了父类的构造函数')
    this.name = name

  }

  bazf111(){
    // this.bazf00()
    super.bazf00()
    // 调用父类的getter
    console.log(super.name);
    // 调用父类的setter
    super.name = '催催催'

    console.log(super.name);

    // 只能用this去调用属性，子类没有去调用父类的
    console.log(this.sex);
    console.log(super.sex); // undefined
    
  }

  bazf00() {
   log('子类的bazf00')
  }

}

let sg = new Shuiguo('pingguo')

console.log( sg.name);
console.log(Shuiguo.sBar);
console.log(sg.sex);
Shuiguo.bar()
sg.bazf00()

sg.bazf111()



